Extensible service execution framework with data mapping architecture

ABSTRACT

A system can comprise a device processor and a memory coupled to the device processor and configured to provide the processor with instructions to: receive a request from a first caller to invoke a software service; automatically obtain an input data mapping expression that is based on a first context tree of a first data model, and based on a current context during execution; evaluate the input data mapping expression to map input data from a first caller context to a service context of the software service; place the mapped input data into a service data consumer object for use by the software service; and invoke the software service to process the mapped input data.

CROSS REFERENCE TO OTHER APPLICATIONS

This application is a continuation of, and claims a benefit of priority under 35 U.S.C. 120 of the filing date of U.S. patent application Ser. No. 15/132,105, filed Apr. 18, 2016, entitled EXTENSIBLE SERVICE EXECUTION FRAMEWORK WITH DATA MAPPING ARCHITECTURE, issued as U.S. Pat. No. 9,880,890, which is a continuation, and claims a benefit of priority under 35 U.S.C. 120 of the filing date of U.S. patent application Ser. No. 14/135,513 filed Dec. 19, 2013, entitled EXTENSIBLE SERVICE EXECUTION FRAMEWORK WITH DATA MAPPING ARCHITECTURE, issued as U.S. Pat. No. 9,342,327, the entire contents of which are hereby expressly incorporated by reference for all purposes.

BACKGROUND OF THE INVENTION

A business process management (“BPM”) engine provides orchestration for sequences of business activities (called a “business process” or simply “process”) in an asynchronous, reliable, and stateful manner.

The business process may be defined as an activity flow model, typically declared using a procedural markup language, for example in eXtensible Markup Language (“XML”). An “activity” represents either human performed tasks or automated software/web services (“Service”) accessed, for example, through an application programming interface (“API”). Services may be invoked from more than within a BPM business process, for example a business process (“Process”), a business event (“Event”) and/or a Java application; collectively these are referred to throughout this specification as a “Caller”.

It would be advantageous to invoke a Service in an extensible execution framework.

BRIEF DESCRIPTION OF THE DRAWINGS

Various embodiments of the invention are disclosed in the following detailed description and the accompanying drawings.

FIG. 1 is a functional diagram illustrating a programmed computer system for distributed workflows in accordance with some embodiments.

FIG. 2A is a block diagram of a process defined in a flow model.

FIG. 2B is a block diagram illustrating a data mapping architecture for the credit score example.

FIG. 3 is a block diagram illustrating a data mapping architecture.

FIG. 4A is a class diagram illustrating a Service interface.

FIG. 4B is a class diagram illustrating a data provider interface.

FIG. 4C is a class diagram illustrating a data consumer interface.

FIG. 4D is a class diagram illustrating a Service binding relationship.

FIGS. 5A and 5B are a sequence diagram illustrating use of the Service binding framework.

FIG. 6 is an illustration of an embodiment for a run-time model Service package in an API.

FIGS. 7A, 7B, 7C, 7D, 7E, 7F, and 7G are illustrations of an embodiment for classes and interfaces within the run-time model Service package.

FIG. 8 is an illustration of an embodiment for a Service package in an API.

FIGS. 9A, 9B, and 9C are illustrations of an embodiment for classes and interfaces within the Service package.

FIG. 10 is an illustration of an embodiment for a Service mapper package in an API.

FIG. 11 is an illustration of an embodiment for a class within the Service mapper package.

FIG. 12 is an illustration of an embodiment for a Service SB package in an API.

FIGS. 13A, 13B, and 13C are an illustration of an embodiment for a Service binding Service executor class.

FIG. 14 is a block diagram illustrating an embodiment of a process for an extensible Service execution framework with a data mapping architecture.

DETAILED DESCRIPTION

The invention can be implemented in numerous ways, including as a process; an apparatus; a system; a composition of matter; a computer program product embodied on a computer readable storage medium; and/or a processor, such as a processor configured to execute instructions stored on and/or provided by a memory coupled to the processor. In this specification, these implementations, or any other form that the invention may take, may be referred to as techniques. In general, the order of the steps of disclosed processes may be altered within the scope of the invention. Unless stated otherwise, a component such as a processor or a memory described as being configured to perform a task may be implemented as a general component that is temporarily configured to perform the task at a given time or a specific component that is manufactured to perform the task. As used herein, the term ‘processor’ refers to one or more devices, circuits, and/or processing cores configured to process data, such as computer program instructions.

A detailed description of one or more embodiments of the invention is provided below along with accompanying figures that illustrate the principles of the invention. The invention is described in connection with such embodiments, but the invention is not limited to any embodiment. The scope of the invention is limited only by the claims and the invention encompasses numerous alternatives, modifications and equivalents. Numerous specific details are set forth in the following description in order to provide a thorough understanding of the invention. These details are provided for the purpose of example and the invention may be practiced according to the claims without some or all of these specific details. For the purpose of clarity, technical material that is known in the technical fields related to the invention has not been described in detail so that the invention is not unnecessarily obscured.

An extensible Service execution framework with a data mapping architecture is disclosed. A Service may be defined throughout this specification as a—service that may for example send an email, call a web service associated with a Representational State Transfer (“REST”) architectural style, perform basic data transformation, or perform any custom service creatable. A Service may be designed by a third-party.

In one embodiment, using the Service involves a design-time (tooling) stage wherein data mapping rules from the Caller's context to the Service context are established. Data mapping rules may include expressions and/or notations. The Caller context may be that associated with a Process and/or an Event. Using the Service also involves a run-time stage to execute the mapping rules while invoking the actual Service.

In one embodiment, a Service can be invoked from within a BPM, from Events, or from plain Java. In one embodiment, a Service is wrapped up in higher level abstractions of data mapping between Caller context and Service context in a generic fashion. The data mapping notations may customized to be suitable to specific contexts, e.g., based on the context tree of a data model.

In one embodiment, an activity template within a Process does input data mapping from Process variables, that is the Caller context, into an email Service. Output mappings may also be determined to map back from the Service, for example a MessageId from email service, to Process variables within the BPM system. An architectural philosophy is disclosed that if Service designers adhere to a generic extensible service execution framework described below, then the data mapping architecture can be automatically implemented at design-time and run-time without custom code. This framework may be used in a variety of systems including EMC Documentum xCP Designer, as well as runtime execution of generic systems, for example Java-based systems.

Three key components on the design-time comprise:

-   -   Determining mapping rules from Caller context to Service         Context;     -   Determining mapping rules from Service context to Caller         Context; and     -   Determining the Service type name string, which is used to         discover and invoke the actual service.

Two key components on the run-time phase comprise:

-   -   Creating a Service based on the Service type name, for example         using a class/interface (known throughout this specification as         a “ServiceFactory” interface) to enable participation of using         the Service in service execution, including in a BPM activity,         Event execution, or another supported run-time system; and     -   Creating the associated Service, including executing input         mappings, executing the service, and executing output mappings,         for example using a class/interface (known throughout this         specification as a “ServiceBindingServiceExecutor” class) to         executes any Service, including an execution logic for an         automatic activity.

FIG. 1 is a functional diagram illustrating a programmed computer system for distributed workflows in accordance with some embodiments. As shown, FIG. 1 provides a functional diagram of a general purpose computer system programmed to execute workflows in accordance with some embodiments. As will be apparent, other computer system architectures and configurations can be used to execute workflows. Computer system 100, which includes various subsystems as described below, includes at least one microprocessor subsystem, also referred to as a processor or a central processing unit (“CPU”) 102. For example, processor 102 can be implemented by a single-chip processor or by multiple cores and/or processors. In one embodiment, processor 102 is a general purpose digital processor that controls the operation of the computer system 100. Using instructions retrieved from memory 110, the processor 102 controls the reception and manipulation of input data, and the output and display of data on output devices, for example display 118.

Processor 102 is coupled bi-directionally with memory 110, which can include a first primary storage, typically a random-access memory (“RAM”), and a second primary storage area, typically a read-only memory (“ROM”). As is well known in the art, primary storage can be used as a general storage area and as scratch-pad memory, and can also be used to store input data and processed data. Primary storage can also store programming instructions and data, in the form of data objects and text objects, in addition to other data and instructions for processes operating on processor 102. Also as well known in the art, primary storage typically includes basic operating instructions, program code, data and objects used by the processor 102 to perform its functions, for example programmed instructions. For example, primary storage devices 110 can include any suitable computer-readable storage media, described below, depending on whether, for example, data access needs to be bi-directional or uni-directional. For example, processor 102 can also directly and very rapidly retrieve and store frequently needed data in a cache memory, not shown. The block processor 102 may also include a coprocessor (not shown) as a supplemental processing component to aid the processor and/or memory 110.

A removable mass storage device 112 provides additional data storage capacity for the computer system 100, and is coupled either bi-directionally (read/write) or uni-directionally (read only) to processor 102. For example, storage 112 can also include computer-readable media such as magnetic tape, flash memory, PC-CARDS, portable mass storage devices, holographic storage devices, and other storage devices. A fixed mass storage 120 can also, for example, provide additional data storage capacity. The most common example of mass storage 120 is a hard disk drive. Mass storage 112, 120 generally store additional programming instructions, data, and the like that typically are not in active use by the processor 102. It will be appreciated that the information retained within mass storage 112, 120 can be incorporated, if needed, in standard fashion as part of primary storage 110, for example RAM, as virtual memory.

In addition to providing processor 102 access to storage subsystems, bus 114 can be used to provide access to other subsystems and devices as well. As shown, these can include a display monitor 118, a network interface 116, a keyboard 104, and a pointing device 106, as well as an auxiliary input/output device interface, a sound card, speakers, and other subsystems as needed. For example, the pointing device 106 can be a mouse, stylus, track ball, or tablet, and is useful for interacting with a graphical user interface.

The network interface 116 allows processor 102 to be coupled to another computer, computer network, or telecommunications network using a network connection as shown. For example, through the network interface 116, the processor 102 can receive information, for example data objects or program instructions, from another network, or output information to another network in the course of performing method/process steps. Information, often represented as a sequence of instructions to be executed on a processor, can be received from and outputted to another network. An interface card or similar device and appropriate software implemented by, for example executed/performed on, processor 102 can be used to connect the computer system 100 to an external network and transfer data according to standard protocols. For example, various process embodiments disclosed herein can be executed on processor 102, or can be performed across a network such as the Internet, intranet networks, or local area networks, in conjunction with a remote processor that shares a portion of the processing. Throughout this specification “network” refers to any interconnection between computer components including the Internet, Ethernet, intranet, local-area network (“LAN”), home-area network (“HAN”), serial connection, parallel connection, wide-area network (“WAN”), Fibre Channel, PCI/PCI-X, AGP, VLbus, PCI Express, Expresscard, Infiniband, ACCESS.bus, Wireless LAN, WiFi, HomePNA, Optical Fibre, G.hn, infrared network, satellite network, microwave network, cellular network, virtual private network (“VPN”), Universal Serial Bus (“USB”), FireWire, Serial ATA, 1-Wire, UNI/O, or any form of connecting homogenous, heterogeneous systems and/or groups of systems together. Additional mass storage devices, not shown, can also be connected to processor 102 through network interface 116.

An auxiliary I/O device interface, not shown, can be used in conjunction with computer system 100. The auxiliary I/O device interface can include general and customized interfaces that allow the processor 102 to send and, more typically, receive data from other devices such as microphones, touch-sensitive displays, transducer card readers, tape readers, voice or handwriting recognizers, biometrics readers, cameras, portable mass storage devices, and other computers.

In addition, various embodiments disclosed herein further relate to computer storage products with a computer readable medium that includes program code for performing various computer-implemented operations. The computer-readable medium is any data storage device that can store data which can thereafter be read by a computer system. Examples of computer-readable media include, but are not limited to, all the media mentioned above: magnetic media such as hard disks, floppy disks, and magnetic tape; optical media such as CD-ROM disks; magneto-optical media such as optical disks; and specially configured hardware devices such as application-specific integrated circuits (“ASIC”s), programmable logic devices (“PLD”s), and ROM and RAM devices. Examples of program code include both machine code, as produced, for example, by a compiler, or files containing higher level code, for example a script, that can be executed using an interpreter.

The computer system shown in FIG. 1 is but an example of a computer system suitable for use with the various embodiments disclosed herein. Other computer systems suitable for such use can include additional or fewer subsystems. In addition, bus 114 is illustrative of any interconnection scheme serving to link the subsystems. Other computer architectures having different configurations of subsystems can also be utilized.

FIG. 2A is a block diagram of a process defined in a flow model. Without loss of generality the process may be defined by proprietary, de facto or industry standards may be used, for example the Business Process Model and Notation (“BPMN”) standard, expressed in a markup language, for example XML, the XML Process Definition Language (“XPDL”) and/or the Business Process Execution Language (“BPEL”). The example given in FIG. 2A is a loan approval process which includes two parallel activities to reach a credit decision (206); a determination of income from a credit application (202) and a determination of a debt to income ratio (204), and on a second path a determination of a social security number (“SSN”) from a credit application (208) and a determination of a credit score (“FICO score”) by invoking a (third-party) service (210) that can transform a SSN to a FICO score.

FIG. 2B is a block diagram illustrating a data mapping architecture for the credit score example. In one embodiment, the diagram in FIG. 2B may exist conceptually in 210 of FIG. 2A. The data provider (252), for example the BPM system in FIG. 2A, provides a social security number in a specified format. Input mapping rules (254) map the social security number in a particular way to form a “SSN” in the Service binding data consumer (256) in another specified format suitable for consumption by the (third-party) Service referenced in 210. The Service after transforming the SSN provides a “Credit Score” in a specified format as shown in the Service binding data provider (258), wherein output mapping rules (260) then map the credit score in a particular way to form a “FICO Score” in the data consumer (262) suitable for consumption by the BPM system in FIG. 2A.

FIG. 3 is a block diagram illustrating a data mapping architecture. In one embodiment, the diagram in FIG. 3 is a generic philosophy for the example in FIG. 2B. FIG. 3 illustrates a Caller (302) calling Service with data mapping between Caller context and Service context and then data being mapped from Service context back to Caller context (308). The Service binding data consumer (304) and Service binding data provider (306) support the data mapping expressions and/or notations based on the context tree of the data model. In one embodiment, it is based on other notations, for example legacy data mapping notations to ensure easy migration to the overall framework.

As shown in FIG. 3, the data provider (302) includes data in a specified format shown as a, b, c, with hierarchical relationship (310), which uses an input data mapping (312) to provide to Service binding data consumer (304) data in a specified format shown as x, y, z with other hierarchical relationship (314). An example of the hierarchical relationship includes that of a “context data tree” as described in greater detail in U.S. patent application Ser. No. 13/626,199 entitled “DATA MODEL BASED CONTEXT TREE”, issued as U.S. Pat. No. 9,430,548, which is incorporated herein by reference for all purposes. In the example shown, (312) includes string function “toLower” on data node a.b and number function “floor” on data node a.c. After the Service has executed on (314), it provides data from Service binding data provider (306) in a specified format shown as p, q, r with other hierarchical relationship (316). Output data mapping (318) transforms data (316) to a consumable format shown as l, m, n with other hierarchical relationship (320). For BPM, the two context trees will be the same based on the Process variables context tree, for example a, b, c, being the same as l, m, n. In one embodiment, a,b,c, and l,m,n are different when multiple services are sequenced.

In the example shown, (318) includes string function “toLower” on data nodes p, q and number function “ceil” on data nodes p, r.

In one embodiment, an overall executing sequence follows this order:

-   -   1) When data mapping expressions/notations are evaluated, it         will first map the data from Caller context into a data consumer         object to be used by the Service. For example, an input mapping         (312) may set a “MailTo” address, “Subject” and “Body” (314) for         an email Service;     -   2) With the values set by the input mapping (312), the Service         is invoked, that is email is sent; and     -   3) Once the Service execution completes, it will execute the         output data mapping (318) and set the values to the Caller         context. For example, an output may be an email message         identification number set to a Process variable in a BPM Process         (320).

Unlike traditional simple data mapping, one embodiment includes a design-time and run-time framework for being a data mapping architecture for an extensible service execution framework, embeddable in any framework that requires some sort of service execution, like BPM systems. The advantages over traditional simple data mapping include:

-   -   1) Being able to call in multiple contexts, as it is not         completely static and/or tied with a particular Process or         Service;     -   2) Being extensible to legacy (using legacy notations as         described above), current, and future third-party Services; and     -   3) Having different types of expressions and/or mapping rules         for different contexts.

The framework creates an entire ecosystem from design-time that creates mapping rules based on the Service selection to run-time.

FIG. 4A is a class diagram illustrating a Service interface. Interface Service< > 402 is implemented by various Service classes, for example a third-party email Service class (404) as well as a Process Service class (406). The public interface Service extends DataConsumer by REQUEST and extends DataProvider by RESPONSE.

FIG. 4B is a class diagram illustrating a data provider interface. Both interfaces ServiceBindingDataProvider (432) and ServiceDefinitionDataProvider (434) inherit from interface DataProvider (436). The EmailResponseServiceBindingDataProvider class (438) implements interface ServiceBindingDataProvider (432) and EmailResponseServiceDefinitionDataProvider class (440) implements interface ServiceDefinitionDataProvider (434). In one embodiment, a Service “definition” data provider is a legacy notation for a Service that has not been updated with a public API, for example the service associated with EmailResponseServiceDefinitionDataProvider (440), and thus does not have the dataMap in EmailResponseServiceBindingDataProvider (438). This illustrates one could retrofit existing legacy mapping rules into new framework and thus also support any new mapping rule notations. By also having the capability to refer to legacy notation, one unique feature that this framework provides is the capability to extend any new type of mapping rules in future.

FIG. 4C is a class diagram illustrating a data consumer interface. Similar to FIG. 4B, both interfaces ServiceDefinitionDataConsumer (452) and ServiceBindingDataConsumer (454) inherit from interface DataConsumer (456). The EmailRequestServiceDefinitionDataConsumer class (458) implements interface ServiceDefinitionDataConsumer (452) and the EmailRequestServiceBindingDataConsumer class (460) implements interface ServiceBindingDataConsumer (454). In one embodiment, the Service definition provides for legacy notation as in FIG. 4B.

FIG. 4D is a class diagram illustrating a Service binding relationship. The Service executor understands a Service binding and executes input mappings, followed by a Service execution, and then output data mapping, as shown in the diagram and the relationship between class ServiceBindingServiceExecutor and class ServiceBindingDataMapperExecutor.

FIGS. 5A and 5B are a sequence diagram illustrating use of the Service binding framework. With regards to (502), (504), (506), (508), (510), (512), and (514), ProcessEngine or any other caller first locates the service in a Service registry by service name and then initializes it one time. If the service name happens to be say an “Email Service” which earlier registered itself with ServiceRegistry with that name, the EmailService is located and then caller initializes it.

With regards to (520), (522), (524), (526), (528), (530), (532), (534), (536), (538), and (540), for each request, based on the current context, the Service is executed. Input data mapping rules are evaluated based on current context data (Caller DataProvider. e.g. ProcessDataProvider), assigned to the Service side (DataConsumer, e.g. EmailRequestServiceBindingDataConsumer), executes the Service, and evaluates output mapping rules based on the data coming from the service execution (DataProvider, e.g. EmailResponseDataProvider) and assigns them to the Data Consumer (e.g. ProcessDataConsumer). With regards to (542), this framework also provides an API to destroy the service and in one embodiment, it is up to the system to determine when to destroy the service.

FIG. 6 is an illustration of an embodiment for a run-time model Service package in an API. In one embodiment, the interfaces include “Resource”; a destroyable resource and “ResourceContext”; used to keep track of resources like files, TCP connections, etc. that can be managed by the lifecycle of a Service execution. The package in FIG. 6 also includes by way of example classes including “EndPoint”; a Service endpoint definition, “ServiceBinding”; a Service binding configuration representation that uses a Spring expression language (“SpEL”) expression to transform from one logical data source to another, “MappingRule”; used by “ServiceBinding” to represent a mapping rule that aids in transforming from one logical data-source to another, and “ServiceDefinition”; a legacy style configuration used to transform a logical data source to another using only the limited set of built-in functions.

FIGS. 7A, 7B, 7C, 7D, 7E, 7F, and 7G are illustrations of an embodiment for classes and interfaces within the run-time model Service package. FIG. 7A is an example of a class definition for “EndPoint”; a Service endpoint definition including a method to get endpoint information as a name-value pair. FIG. 7B is an example of a class definition for “MappingRule”; used by “ServiceBinding” to represent a mapping rule that aids in transforming from one logical data-source to another, including a method to get an expression using constants (or variables based on the context of/from the data tree), and a method to get to a target node to transform an expression result. FIG. 7C is an example of a class definition for “ServiceBinding”; a Service binding configuration representation that uses a SpEL expression to transform from one logical data source to another. FIG. 7D is an example of a class definition for “ServiceDefinition”; a legacy style configuration used to transform a logical data source to another using only the limited set of built-in functions. FIG. 7E is an example of a class definition for “ServiceDefinition.MappingRule”; to perform the mapping of the legacy style configuration. FIG. 7F is an example of an interface “Resource”; a destroyable resource. FIG. 7G is an example of an interface “ResourceContext”; used to keep track of resources like files, TCP connections, etc. that can be managed by the lifecycle of a Service execution.

FIG. 8 is an illustration of an embodiment for a Service package in an API. In one embodiment, the interfaces include “DataConsumer”; a marker interface to aid in setting values to a data tree, “DataProvider”; a marker interface to aid in getting values from a data tree; “Service< >”; an interface representing the Service; and “ServiceFactory”, an interface enabling participation of using a Service in Service execution, for example in a BPM activity, in Event execution, or other supported runtime systems like plain Java. The package in FIG. 8 also includes by way of example a class like “ServiceFactoryRegistry”; a Service discovery class.

FIGS. 9A, 9B, and 9C are illustrations of an embodiment for classes and interfaces within the Service package. FIG. 9A is an example of a class definition for “ServiceFactoryRegistry”; a Service discovery class including a method for a (Spring) Bean Post Processor to add a given service factory to a registry (typically used in a non-OSGi environment), a method to finds a service factory handle for a given service name, and a method used by Spring BluePrint to register all service factories. FIG. 9B is an example of an interface “Service< >”; an interface representing the Service, including:

-   -   an init method to initialize any resources (for example, a JMS         connection) and that can be reused across multiple invoke         services, including a parameter for a map representing the         endpoint information, e.g. Email Host and Port etc,     -   a REQUEST/createServiceRequestDataConsumer method to return the         Service's data consumer which will be used to set values before         service invocation, including a parameter for context         (information that could be passed into service execution), a         parameter that allows in some cases like Process data mapping,         the DataConsumer being the same as DataProvider—that is doing         basic data transformation, and returns DataConsumer that can be         used to set values to Service before invoking it,     -   an invokeService method to invoke a Service, including a         parameter for context (information that could be passed into         service execution), and a parameter for a data consumer that has         details (like email request data) used in invoking the service,         and     -   a destroy method to destroy any resources created in the init         method.

FIG. 9C is an example of an interface “ServiceFactory”; an interface enabling participation of using a Service in Service execution, for example in a BPM activity, in Event execution, or other supported runtime systems like plain Java, including a method to create a new Service, and a method used as an identifier to discover a Service, wherein Services are typically discovered based on configuration provided using a ServiceDefinition or a ServiceBinding format.

FIG. 10 is an illustration of an embodiment for a Service mapper package in an API. In one embodiment, the interfaces include “BPMServiceFactory”; a ServiceFactory extension that provides support for ServiceBinding and/or ServiceDefinition abstraction in order to enable a Service implementer to call the service from ServiceBinding/ServiceDefinition, “BPMServiceFactoryRegistryService”; a Service discovery interface, “ServiceBindingDataConsumer”; an interface to aid in setting values to a data tree for a configuration provided using Service binding, “ServiceBindingDataProvider”; an interface to aid in getting values from a data tree for a configuration based on a Service binding, “ServiceDefinitionDataConsumer” an interface to aid in setting values to a data tree for a configuration provided using a Service definition, and “ServiceDefinitionDataProvider”, an interface to aid in getting values from a data tree for a configuration based on a Service definition. The package in FIG. 10 also includes by way of example classes like “BPMServiceFactoryRegistryServiceImpl”; a Service discovery class and “ServiceHandler”; a context class that allows inter-operability with non-Spring classes.

FIG. 11 is an illustration of an embodiment for a class within the Service mapper package. FIG. 11 is an example of “BPMServiceFactoryRegistryServiceImpl”; a Service discovery class, including a getServiceFactory method to find the service factory handle for a given service name, an addServiceFactory method used by (Spring) Bean Post Processor to add a given service factory to this registry (typically used in an non-OSGi environment), and a setServiceFactories method used by Spring BluePrint to register all service factories.

FIG. 12 is an illustration of an embodiment for a Service SB package in an API. In one embodiment the classes include “ServiceBindingDataMapperExecutor”; a framework class that allows execution of mapping rules during the execution of every Service binding configuration that is an internal class and would not have any significance to the implementer of the Service, “ServiceBindingServiceExecutor”; a class that executes any Service, and “ServiceBindingVariableTypeInfoProvider”; a framework class that allows getting more information on variables using an expression that is part of a ServiceBinding configuration.

FIGS. 13A, 13B, and 13C are an illustration of an embodiment for a Service binding Service executor class. FIG. 13A-C are an example of “ServiceBindingServiceExecutor”; a class which executes any Service. Again, a Service is an execution logic for an automatic activity. This Service executor is based on ServiceBinding. In one embodiment, there are other kinds of executors that are more suitable in an non-automatic activity context. This class includes methods:

-   -   an init method to initialize a Service provided in the Service         binding configuration using parameters including context used         for processing the init( ) when the service is initialized,     -   an execute method to execute a service that may not have any         output mapping using parameters including context used for         processing the execution of service, and a         fromRequestDataProviders parameter for data providers that         participate in the Service binding, for example         ProcessDataProvider when used in an BPM activity,     -   an execute method to execute a service that have both input and         output mapping using parameters including context used for         processing the execution of service, a fromRequestDataProviders         parameter for data providers that participate in the Service         binding, for example ProcessDataProvider when used in an BPM         activity, and a toResponseDataConsumer parameter for data         consumers that participate in the Service binding, for example         ProcessDataConsumer when used in an BPM Activity), and     -   a destroy method for Service cleanup during shutdown of the         service and/or when the service is not required to be loaded in         memory.

FIG. 14 is a block diagram illustrating an embodiment of a process for an extensible Service execution framework with a data mapping architecture. In one embodiment, the process of FIG. 14 is executed in the system of FIG. 1.

In step 1402, a Service description associated with a Service is received. In one embodiment, the service is a web Service. In one embodiment, the Service description is received during design-time. In one embodiment, the Service description is received in EMC Documentum xCP Designer. In one embodiment, the Service description conforms to an API like that described in FIGS. 6 through 13C. In one embodiment, the web Service is associated with a REST architectural style. In one embodiment, the web Service is invoked from a BPM, an Event and/or from Java.

In step 1404, an input data mapping rule is automatically determined from a first Caller context to a Service context associated with the web Service at least in part by transforming the Service description. In one embodiment, the input data mapping rule is automatically determined at design-time. In one embodiment, a step (not shown) is further included automatically determining an output data mapping rule from the Service context to a second Caller context at least in part by transforming the Service description. In one embodiment, the output data mapping rule is automatically determined during design-time. In one embodiment, the second Caller context is the same as the first Caller context, that is from the same BPM, Event, and/or Java application.

In step 1406, a Service binding data consumer is created based at least in part on the Service description. In one embodiment, the Service binding data consumer is created at run-time. In one embodiment, a step (not shown) is further included creating a Service binding data provider based at least in part on the Service description. In one embodiment, the Service binding data provider is created during run-time.

In step 1408, the service and the input data mapping rule between the first Caller context and the Service context is automatically executed. In one embodiment, the web Service and the input data mapping rule are automatically executed during run-time. In one embodiment, a step (not shown) is further included automatically executing the web Service and the output data mapping rule between the Service context and a second Caller context. In one embodiment, the web Service and the output data mapping rule are automatically executed during run-time. In one embodiment, the second Caller context is the first Service context, that is the Service outputs to itself. In one embodiment, the second Caller context is a next Service context, that is the results from the first Service are “daisy chained” to a second Service.

Although the foregoing embodiments have been described in some detail for purposes of clarity of understanding, the invention is not limited to the details provided. There are many alternative ways of implementing the invention. The disclosed embodiments are illustrative and not restrictive. 

The invention claimed is:
 1. A system, comprising: a device processor; and a memory coupled to the device processor and configured to provide the device processor with a set of instructions to, at run-time: based at least in part on a request from a first caller to initialize a software service, create an input mapper object based at least in part on a service binding configuration for the software service, the input mapper object configured to execute an input data mapping rule to map data from a first caller context to a service context of the software service, the input data mapping rule comprising an input data mapping expression based on a first context tree of a first data model; receive a request from the first caller to invoke the software service to process a first set of input data; in response to the request by the first caller to invoke the software service: create a service binding data consumer object based at least in part on the service binding configuration, the service binding data consumer object configured to set values for use by the software service; evaluate, by the input mapper object, the input data mapping expression based on a current context to map the first set of input data to mapped input data, the input data mapping expression specifying a mapping of the first set of input data from one logical data source to another logical data source; place the mapped input data into the service binding data consumer object for use by the software service; and invoke the software service to process the mapped input data, wherein invoking the software service comprises passing a parameter for the service binding data consumer object that has the mapped input data.
 2. A system as recited in claim 1, wherein evaluating the input data mapping expression comprises executing the input data mapping expression.
 3. A system as recited in claim 1, wherein the set of instructions further comprises instructions to: create an output data mapper object based at least in part on the service binding configuration, the output data mapper object configured to execute an output data mapping rule to map data from the service context to a first recipient context, the output data mapping rule comprising an output data mapping expression; create a service binding data producer object configured to get output data according the service context of the software service; and after invoking the software service, evaluate the output data mapping expression to map output data from service binding data producer object to mapped output data according to the first recipient context.
 4. A system as recited in claim 3, wherein the set of instructions further comprises instructions to: place the mapped output data into a process variable for use by a first recipient.
 5. A system as recited in claim 3, wherein the service binding data producer object is configured to enable getting values from a data tree.
 6. A system as recited in claim 1, wherein the service binding data consumer object is configured to enable setting values in a data tree according to the service context.
 7. A system as recited in claim 1, wherein the set of instructions further comprises instruction to: receive a service description associated with the software service during a tooling stage, wherein the tooling stage is performed at design-time before the run-time.
 8. A system as recited in claim 7, wherein the set of instructions further comprises instructions to: automatically determine at the tooling stage the input data mapping rule at least in part by transforming the service description and associate, with the service description, at least an indication of executable instructions for mapping between the first caller context and the service context, the input data mapping rule based on the first context tree of the first data model.
 9. A system as recited in claim 8, wherein the set of instructions further comprises instructions to: automatically determine at the tooling stage an output data mapping rule that maps output data from the service context to a second caller context based on a second context tree of a second data model.
 10. A system, comprising: a device processor; and a memory coupled to the device processor and configured to provide the device processor with a set of instructions to, at a run-time: based at least in part on a request from a first caller to initialize a software service, create an input mapper object based at least in part on a service binding configuration for the software service, the input mapper object configured to execute an input data mapping rule to map data from a first caller context to a service context of the software service, the input data mapping rule comprising an input data mapping expression based on a first context tree of a first data model; in response to a request from the first caller to invoke the software service to process a first set of input data: create a service binding data consumer object based at least in part on the service binding configuration, the service binding data consumer object configured to set values for use by the software service; evaluate, by the input mapper object, the input data mapping expression based on a current context to map the first set of input data to mapped input data, the input data mapping expression specifying a mapping of input data from one logical data source to another logical data source; store the mapped input data for use by the software service by setting one or more values in a data tree using the service binding data consumer object; and invoke the software service to process the mapped input data, wherein invoking the service binding data consumer object comprises passing a parameter for the service binding data consumer object that has the mapped input data.
 11. A system as recited in claim 10, wherein the set of instructions further comprises instructions to: create an output data mapper object based at least in part on the service binding configuration, the output data mapper object configured to execute an output data mapping rule to map data from the service context to a first recipient context, the output data mapping rule comprising an output data mapping expression; create a service binding data producer object configured to get output data according the service context of the software service; and after invoking the software service, evaluate the output data mapping expression to map output data from the service binding data producer object to mapped output data according to the first recipient context.
 12. A system as recited in claim 11, wherein the set of instructions further comprises instructions to: place the mapped output data into a process variable for use by a first recipient.
 13. A system as recited in claim 10, wherein the service binding data consumer object is configured to enable setting the one or more values in the data tree.
 14. A system as recited in claim 10, wherein the set of instructions further comprises instructions to: receive a service description associated with the software service during a tooling stage, wherein the tooling stage is performed at design-time before the run-time.
 15. A system as recited in claim 14, wherein the set of instructions further comprises instructions to: automatically determine at the tooling stage the input data mapping rule at least in part by transforming the service description and associate, with the service description, at least an indication of executable instructions for mapping between the first caller context and the service context, the input data mapping rule based on the first context tree of the first data model.
 16. A system as recited in claim 15, wherein the set of instructions further comprises instructions to: automatically determine at the tooling stage an output data mapping rule that maps output data from the service context to a second caller context based on a second context tree of a second data model.
 17. A non-transitory computer readable storage medium storing computer instructions for, during a run-time: based at least in part on a request from a first caller to initialize a software service, creating an input mapper object based at least in part on a service binding configuration for the software service, the input mapper object configured to execute an input data mapping rule to map data from a first caller context to a service context of the software service, the input data mapping rule comprising an input data mapping expression based on a first context tree of a first data model; receiving a request from the first caller to invoke the software service to process a first set of input data; in response to the request from the first caller to invoke the software service: creating a service binding data consumer object based at least in part on the service binding configuration, the service binding data consumer object configured to set values for use by the software service; evaluating, by the input mapper object, the input data mapping expression based on a current context to map the first set of input data to mapped input data, the input data mapping expression specifying a mapping of input data from one logical data source to another logical data source; placing the mapped input data into the service binding data consumer object for use by the software service; and invoking the software service to process the mapped input data, wherein invoking the software service comprises passing a parameter for the service binding data consumer object that has the mapped input data.
 18. The non-transitory computer readable storage medium of claim 17, further comprising computer instructions for receiving a service description associated with the software service during a tooling stage, wherein the tooling stage is performed at design-time before the run-time.
 19. The non-transitory computer readable storage medium of claim 18, further comprising instructions for: automatically determining at the tooling stage the input data mapping rule at least in part by transforming the service description and associating, with the service description, at least an indication of executable instructions for mapping between the first caller context and the service context, the input data mapping rule based on the first context tree of the first data model.
 20. The non-transitory computer readable storage medium of claim 18, further comprising instructions for: automatically determining at the tooling stage an output data mapping rule that maps output data from the service context to a second caller context based on a second context tree of a second data model. 